Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/lib/python2.4/test/test_funcattrs.pyo

Python Compiled Bytecode | 2005-10-18 | 12KB | 550 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.4)

from test.test_support import verbose, TestFailed, verify
import types

class F:

    def a(self):
        pass



def b():
    '''my docstring'''
    pass

verify(b.__module__ == __name__)
verify(verify.__module__ == 'test.test_support')

try:
    b.publish
except AttributeError:
    pass

raise TestFailed, 'expected AttributeError'
if b.__dict__ != { }:
    raise TestFailed, 'expected unassigned func.__dict__ to be {}'

b.publish = 1
if b.publish != 1:
    raise TestFailed, 'function attribute not set to expected value'

docstring = 'its docstring'
b.__doc__ = docstring
if b.__doc__ != docstring:
    raise TestFailed, 'problem with setting __doc__ attribute'

if 'publish' not in dir(b):
    raise TestFailed, 'attribute not in dir()'


try:
    del b.__dict__
except TypeError:
    pass

raise TestFailed, 'del func.__dict__ expected TypeError'
b.publish = 1

try:
    b.__dict__ = None
except TypeError:
    pass

raise TestFailed, 'func.__dict__ = None expected TypeError'
d = {
    'hello': 'world' }
b.__dict__ = d
if b.func_dict is not d:
    raise TestFailed, 'func.__dict__ assignment to dictionary failed'

if b.hello != 'world':
    raise TestFailed, 'attribute after func.__dict__ assignment failed'

f1 = F()
f2 = F()

try:
    F.a.publish
except AttributeError:
    pass

raise TestFailed, 'expected AttributeError'

try:
    f1.a.publish
except AttributeError:
    pass

raise TestFailed, 'expected AttributeError'

try:
    F.a.publish = 1
except (AttributeError, TypeError):
    pass

raise TestFailed, 'expected AttributeError or TypeError'
F.a.im_func.publish = 1
if F.a.publish != 1:
    raise TestFailed, 'unbound method attribute not set to expected value'

if f1.a.publish != 1:
    raise TestFailed, 'bound method attribute access did not work'

if f2.a.publish != 1:
    raise TestFailed, 'bound method attribute access did not work'

if 'publish' not in dir(F.a):
    raise TestFailed, 'attribute not in dir()'


try:
    f1.a.publish = 0
except (AttributeError, TypeError):
    pass

raise TestFailed, 'expected AttributeError or TypeError'

try:
    F.a.myclass = F
except (AttributeError, TypeError):
    pass

raise TestFailed, 'expected AttributeError or TypeError'
F.a.im_func.myclass = F
f1.a.myclass
f2.a.myclass
f1.a.myclass
F.a.myclass
if f1.a.myclass is not f2.a.myclass or f1.a.myclass is not F.a.myclass:
    raise TestFailed, 'attributes were not the same'


try:
    F.a.__dict__ = (1, 2, 3)
except (AttributeError, TypeError):
    pass

raise TestFailed, 'expected TypeError or AttributeError'
F.a.im_func.__dict__ = {
    'one': 11,
    'two': 22,
    'three': 33 }
if f1.a.two != 22:
    raise TestFailed, 'setting __dict__'

from UserDict import UserDict
d = UserDict({
    'four': 44,
    'five': 55 })

try:
    F.a.__dict__ = d
except (AttributeError, TypeError):
    pass

raise TestFailed
if f1.a.one != f1.a.one and F.a.one != F.a.one:
    pass
elif F.a.one != 11:
    raise TestFailed

import new
F.id = new.instancemethod(id, None, F)
eff = F()

try:
    F.id.foo
except AttributeError:
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

try:
    F.id.foo = 12
except (AttributeError, TypeError):
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

try:
    F.id.foo
except AttributeError:
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

try:
    eff.id.foo
except AttributeError:
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

try:
    eff.id.foo = 12
except (AttributeError, TypeError):
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

try:
    eff.id.foo
except AttributeError:
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

def another():
    pass


try:
    del another.__dict__
except TypeError:
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

try:
    del another.func_dict
except TypeError:
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

try:
    another.func_dict = None
except TypeError:
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed

try:
    del another.bar
except AttributeError:
    None if eff.id() != id(eff) else f2.a.one
    None if eff.id() != id(eff) else f2.a.one
except:
    None if eff.id() != id(eff) else f2.a.one

raise TestFailed
del another.func_defaults

def foo():
    pass


def bar():
    pass


def temp():
    print 1

if foo == bar:
    raise TestFailed

d = { }
d[foo] = 1
foo.func_code = temp.func_code
d[foo]

def cantset(obj, name, value, exception = (AttributeError, TypeError)):
    verify(hasattr(obj, name))

    try:
        setattr(obj, name, value)
    except exception:
        pass

    raise TestFailed, "shouldn't be able to set %s to %r" % (name, value)

    try:
        delattr(obj, name)
    except (AttributeError, TypeError):
        pass

    raise TestFailed, "shouldn't be able to del %s" % name


def test_func_closure():
    a = 12

    def f():
        print a

    c = f.func_closure
    verify(isinstance(c, tuple))
    verify(len(c) == 1)
    verify(c[0].__class__.__name__ == 'cell')
    cantset(f, 'func_closure', c)


def test_func_doc():

    def f():
        pass

    verify(f.__doc__ is None)
    verify(f.func_doc is None)
    f.__doc__ = 'hello'
    verify(f.__doc__ == 'hello')
    verify(f.func_doc == 'hello')
    del f.__doc__
    verify(f.__doc__ is None)
    verify(f.func_doc is None)
    f.func_doc = 'world'
    verify(f.__doc__ == 'world')
    verify(f.func_doc == 'world')
    del f.func_doc
    verify(f.func_doc is None)
    verify(f.__doc__ is None)


def test_func_globals():

    def f():
        pass

    verify(f.func_globals is globals())
    cantset(f, 'func_globals', globals())


def test_func_name():

    def f():
        pass

    verify(f.__name__ == 'f')
    verify(f.func_name == 'f')
    f.__name__ = 'g'
    verify(f.__name__ == 'g')
    verify(f.func_name == 'g')
    f.func_name = 'h'
    verify(f.__name__ == 'h')
    verify(f.func_name == 'h')
    cantset(f, 'func_globals', 1)
    cantset(f, '__name__', 1)
    s = 'def f(): pass\nf.__name__'
    exec s in {
        '__builtins__': { } }


def test_func_code():
    a = b = 24

    def f():
        pass


    def g():
        print 12


    def f1():
        print a


    def g1():
        print b


    def f2():
        print a, b

    verify(type(f.func_code) is types.CodeType)
    f.func_code = g.func_code
    cantset(f, 'func_code', None)
    cantset(f, 'func_code', f1.func_code, exception = ValueError)
    cantset(f1, 'func_code', f.func_code, exception = ValueError)
    cantset(f1, 'func_code', f2.func_code, exception = ValueError)
    f1.func_code = g1.func_code


def test_func_defaults():

    def f(a, b):
        return (a, b)

    verify(f.func_defaults is None)
    f.func_defaults = (1, 2)
    verify(f.func_defaults == (1, 2))
    verify(f(10) == (10, 2))

    def g(a = 1, b = 2):
        return (a, b)

    verify(g.func_defaults == (1, 2))
    del g.func_defaults
    verify(g.func_defaults is None)

    try:
        g()
    except TypeError:
        pass

    raise TestFailed, "shouldn't be allowed to call g() w/o defaults"


def test_func_dict():

    def f():
        pass

    a = f.__dict__
    b = f.func_dict
    verify(a == { })
    verify(a is b)
    f.hello = 'world'
    verify(a == {
        'hello': 'world' })
    None(verify if a is a else a is f.__dict__)
    f.func_dict = { }
    verify(not hasattr(f, 'hello'))
    f.__dict__ = {
        'world': 'hello' }
    verify(f.world == 'hello')
    None(None if f.func_dict is f.func_dict else f.__dict__ == {
        'world': 'hello' })
    cantset(f, 'func_dict', None)
    cantset(f, '__dict__', None)


def test_im_class():

    class C:

        def foo(self):
            pass


    verify(C.foo.im_class is C)
    verify(C().foo.im_class is C)
    cantset(C.foo, 'im_class', C)
    cantset(C().foo, 'im_class', C)


def test_im_func():

    def foo(self):
        pass


    class C:
        pass

    C.foo = foo
    verify(C.foo.im_func is foo)
    verify(C().foo.im_func is foo)
    cantset(C.foo, 'im_func', foo)
    cantset(C().foo, 'im_func', foo)


def test_im_self():

    class C:

        def foo(self):
            pass


    verify(C.foo.im_self is None)
    c = C()
    verify(c.foo.im_self is c)
    cantset(C.foo, 'im_self', None)
    cantset(c.foo, 'im_self', c)


def test_im_dict():

    class C:

        def foo(self):
            pass

        foo.bar = 42

    verify(C.foo.__dict__ == {
        'bar': 42 })
    verify(C().foo.__dict__ == {
        'bar': 42 })
    cantset(C.foo, '__dict__', C.foo.__dict__)
    cantset(C().foo, '__dict__', C.foo.__dict__)


def test_im_doc():

    class C:

        def foo(self):
            '''hello'''
            pass


    verify(C.foo.__doc__ == 'hello')
    verify(C().foo.__doc__ == 'hello')
    cantset(C.foo, '__doc__', 'hello')
    cantset(C().foo, '__doc__', 'hello')


def test_im_name():

    class C:

        def foo(self):
            pass


    verify(C.foo.__name__ == 'foo')
    verify(C().foo.__name__ == 'foo')
    cantset(C.foo, '__name__', 'foo')
    cantset(C().foo, '__name__', 'foo')


def testmore():
    test_func_closure()
    test_func_doc()
    test_func_globals()
    test_func_name()
    test_func_code()
    test_func_defaults()
    test_func_dict()
    test_im_class()
    test_im_func()
    test_im_self()
    test_im_dict()
    test_im_doc()
    test_im_name()

testmore()